ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள்: நவீன பயன்பாடுகளுக்கான ஸ்ட்ரீம் உருமாற்றம்

நவீன வலை மற்றும் சர்வர்-பக்க மேம்பாட்டின் வேகமாக மாறிவரும் சூழலில், ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களை திறமையாக கையாள்வது மிக முக்கியம். ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர்கள், சக்திவாய்ந்த காம்பினேட்டர்களுடன் இணைந்து, இந்த ஸ்ட்ரீம்களை உருமாற்றுவதற்கும் கையாளுவதற்கும் ஒரு நேர்த்தியான மற்றும் செயல்திறன் மிக்க தீர்வை வழங்குகின்றன. இந்த விரிவான வழிகாட்டி அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களின் கருத்தை ஆராய்ந்து, அவற்றின் நன்மைகள், நடைமுறை பயன்பாடுகள் மற்றும் உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கான உலகளாவிய கருத்தாய்வுகளைக் காட்டுகிறது.

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களைப் புரிந்துகொள்ளுதல்

காம்பினேட்டர்களுக்குள் நுழைவதற்கு முன், அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்கள் பற்றிய உறுதியான புரிதலை ஏற்படுத்துவோம். ECMAScript 2018 இல் அறிமுகப்படுத்தப்பட்ட இந்த அம்சங்கள், ஒத்திசைவற்ற தரவு வரிசைகளுடன் ஒரு கட்டமைக்கப்பட்ட மற்றும் கணிக்கக்கூடிய முறையில் வேலை செய்ய நமக்கு உதவுகின்றன.

அசிங்க் இட்டரேட்டர்கள்

ஒரு அசிங்க் இட்டரேட்டர் என்பது ஒரு ஆப்ஜெக்ட் ஆகும், இது ஒரு next() முறையை வழங்குகிறது, இது value மற்றும் done என்ற இரண்டு பண்புகளுடன் ஒரு ஆப்ஜெக்ட்டாக தீர்க்கப்படும் ஒரு ப்ராமிஸை வழங்குகிறது. value பண்பு வரிசையில் அடுத்த மதிப்பைக் கொண்டுள்ளது, மற்றும் done பண்பு இட்டரேட்டர் வரிசையின் முடிவை அடைந்துவிட்டதா என்பதைக் குறிக்கிறது.

இதோ ஒரு எளிய எடுத்துக்காட்டு:

            
const asyncIterable = {
  [Symbol.asyncIterator]() {
    let i = 0;
    return {
      async next() {
        await new Promise(resolve => setTimeout(resolve, 100)); // Simulate asynchronous operation
        if (i < 3) {
          return { value: i++, done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

(async () => {
  for await (const value of asyncIterable) {
    console.log(value); // Output: 0, 1, 2
  }
})();

            

              
                Copy
              
            
          

அசிங்க் ஜெனரேட்டர்கள்

அசிங்க் ஜெனரேட்டர்கள் அசிங்க் இட்டரேட்டர்களை உருவாக்குவதற்கு ஒரு சுருக்கமான தொடரியலை வழங்குகின்றன. அவை async function* தொடரியலுடன் அறிவிக்கப்பட்ட செயல்பாடுகள் ஆகும், மேலும் அவை yield என்ற முக்கியச்சொல்லைப் பயன்படுத்தி மதிப்புகளை ஒத்திசைவற்ற முறையில் உருவாக்குகின்றன.

இதோ அதே எடுத்துக்காட்டு அசிங்க் ஜெனரேட்டரைப் பயன்படுத்தி:

            
async function* asyncGenerator() {
  let i = 0;
  while (i < 3) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

(async () => {
  for await (const value of asyncGenerator()) {
    console.log(value); // Output: 0, 1, 2
  }
})();

            

              
                Copy
              
            
          

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்கள் ஜாவாஸ்கிரிப்ட்டில் ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களுடன் வேலை செய்வதற்கான அடிப்படைக் கட்டுமானத் தொகுதிகள் ஆகும். அவை பிரதான த்ரெட்டைத் தடுக்காமல், தரவு கிடைக்கும்போது அதைச் செயல்படுத்த நமக்கு உதவுகின்றன.

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களை அறிமுகப்படுத்துதல்

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் என்பவை ஒன்று அல்லது அதற்கு மேற்பட்ட அசிங்க் இட்டரேட்டர்களை உள்ளீடாக எடுத்து, உள்ளீட்டு ஸ்ட்ரீம்களை ஏதேனும் ஒரு வழியில் உருமாற்றும் அல்லது இணைக்கும் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்கும் செயல்பாடுகள் ஆகும். அவை செயல்பாட்டு நிரலாக்கக் கருத்துக்களால் ஈர்க்கப்பட்டு, ஒத்திசைவற்ற தரவைக் கையாளுவதற்கான சக்திவாய்ந்த மற்றும் ஒருங்கிணைக்கக்கூடிய வழியை வழங்குகின்றன.

சில செயல்பாட்டு மொழிகளைப் போல ஜாவாஸ்கிரிப்ட்டில் உள்ளமைக்கப்பட்ட அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் இல்லை என்றாலும், நாம் அவற்றை எளிதாக நாமே செயல்படுத்தலாம் அல்லது ஏற்கனவே உள்ள லைப்ரரிகளைப் பயன்படுத்தலாம். சில பொதுவான மற்றும் பயனுள்ள காம்பினேட்டர்களை ஆராய்வோம்.

1. map

map காம்பினேட்டர், உள்ளீட்டு அசிங்க் இட்டரேட்டரால் வெளியிடப்படும் ஒவ்வொரு மதிப்பிற்கும் கொடுக்கப்பட்ட ஒரு செயல்பாட்டைப் பயன்படுத்துகிறது மற்றும் உருமாற்றப்பட்ட மதிப்புகளை வெளியிடும் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகிறது. இது அரேக்களுக்கான map செயல்பாட்டைப் போன்றது.

            
async function* map(iterable, fn) {
  for await (const value of iterable) {
    yield await fn(value);
  }
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

async function square(x) {
  await new Promise(resolve => setTimeout(resolve, 50)); // Simulate async operation
  return x * x;
}

(async () => {
  const squaredNumbers = map(numberGenerator(), square);
  for await (const value of squaredNumbers) {
    console.log(value); // Output: 1, 4, 9 (with delays)
  }
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: map காம்பினேட்டர் வெவ்வேறு பிராந்தியங்கள் மற்றும் தொழில்துறைகளில் பரவலாகப் பொருந்தும். உருமாற்றங்களைப் பயன்படுத்தும்போது, உள்ளூர்மயமாக்கல் மற்றும் சர்வதேசமயமாக்கல் தேவைகளைக் கருத்தில் கொள்ளுங்கள். எடுத்துக்காட்டாக, தேதிகள் அல்லது எண்களை உள்ளடக்கிய தரவை நீங்கள் மேப்பிங் செய்கிறீர்கள் என்றால், உருமாற்றச் செயல்பாடு வெவ்வேறு பிராந்திய வடிவங்களைச் சரியாகக் கையாள்வதை உறுதிசெய்யவும்.

2. filter

filter காம்பினேட்டர் உள்ளீட்டு அசிங்க் இட்டரேட்டரிலிருந்து கொடுக்கப்பட்ட ஒரு பிரடிகேட் செயல்பாட்டை திருப்திப்படுத்தும் மதிப்புகளை மட்டுமே வெளியிடுகிறது.

            
async function* filter(iterable, predicate) {
  for await (const value of iterable) {
    if (await predicate(value)) {
      yield value;
    }
  }
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

async function isEven(x) {
  await new Promise(resolve => setTimeout(resolve, 50));
  return x % 2 === 0;
}

(async () => {
  const evenNumbers = filter(numberGenerator(), isEven);
  for await (const value of evenNumbers) {
    console.log(value); // Output: 2, 4 (with delays)
  }
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: filter-இல் பயன்படுத்தப்படும் பிரடிகேட் செயல்பாடுகள் கலாச்சார அல்லது பிராந்திய தரவு வேறுபாடுகளைக் கருத்தில் கொள்ள வேண்டியிருக்கலாம். உதாரணமாக, வயது அடிப்படையில் பயனர் தரவை வடிகட்டுவதற்கு வெவ்வேறு நாடுகளில் வெவ்வேறு வரம்புகள் அல்லது சட்டரீதியான கருத்தாய்வுகள் தேவைப்படலாம்.

3. take

take காம்பினேட்டர் உள்ளீட்டு அசிங்க் இட்டரேட்டரிலிருந்து முதல் n மதிப்புகளை மட்டுமே வெளியிடுகிறது.

            
async function* take(iterable, n) {
  let i = 0;
  for await (const value of iterable) {
    if (i < n) {
      yield value;
      i++;
    } else {
      return;
    }
  }
}

// Example:
async function* infiniteNumberGenerator() {
  let i = 0;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield i++;
  }
}

(async () => {
  const firstFiveNumbers = take(infiniteNumberGenerator(), 5);
  for await (const value of firstFiveNumbers) {
    console.log(value); // Output: 0, 1, 2, 3, 4 (with delays)
  }
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: நீங்கள் ஒரு சாத்தியமான எல்லையற்ற ஸ்ட்ரீமின் ஒரு குறிப்பிட்ட துணைக்குழுவைச் செயல்படுத்த வேண்டிய சூழ்நிலைகளில் take பயனுள்ளதாக இருக்கும். வெவ்வேறு உள்கட்டமைப்புத் திறன்களைக் கொண்ட வெவ்வேறு பிராந்தியங்களில் உள்ள கணினிகளை அதிகமாகப் பாதிப்பதைத் தவிர்க்க API கோரிக்கைகள் அல்லது தரவுத்தள வினவல்களைக் கட்டுப்படுத்த இதைப் பயன்படுத்தலாம்.

4. drop

drop காம்பினேட்டர் உள்ளீட்டு அசிங்க் இட்டரேட்டரிலிருந்து முதல் n மதிப்புகளைத் தவிர்த்து, மீதமுள்ள மதிப்புகளை வெளியிடுகிறது.

            
async function* drop(iterable, n) {
  let i = 0;
  for await (const value of iterable) {
    if (i >= n) {
      yield value;
    } else {
      i++;
    }
  }
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

(async () => {
  const remainingNumbers = drop(numberGenerator(), 2);
  for await (const value of remainingNumbers) {
    console.log(value); // Output: 3, 4, 5
  }
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: take போலவே, பெரிய தரவுத்தொகுப்புகளுடன் கையாளும் போது drop மதிப்புமிக்கதாக இருக்கும். உலகளவில் விநியோகிக்கப்பட்ட தரவுத்தளத்திலிருந்து உங்களுக்கு ஒரு தரவு ஸ்ட்ரீம் இருந்தால், நேரமுத்திரை அல்லது வரிசை எண்ணின் அடிப்படையில் ஏற்கனவே செயலாக்கப்பட்ட பதிவுகளைத் தவிர்க்க drop-ஐப் பயன்படுத்தலாம், இது வெவ்வேறு புவியியல் இருப்பிடங்களில் திறமையான ஒத்திசைவை உறுதி செய்கிறது.

5. reduce

reduce காம்பினேட்டர் கொடுக்கப்பட்ட ஒரு ரெடியூசர் செயல்பாட்டைப் பயன்படுத்தி உள்ளீட்டு அசிங்க் இட்டரேட்டரிலிருந்து வரும் மதிப்புகளை ஒரே மதிப்பாகக் குவிக்கிறது. இது அரேக்களுக்கான reduce செயல்பாட்டைப் போன்றது.

            
async function reduce(iterable, reducer, initialValue) {
  let accumulator = initialValue;
  for await (const value of iterable) {
    accumulator = await reducer(accumulator, value);
  }
  return accumulator;
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

async function sum(a, b) {
  await new Promise(resolve => setTimeout(resolve, 50));
  return a + b;
}

(async () => {
  const total = await reduce(numberGenerator(), sum, 0);
  console.log(total); // Output: 15 (after delays)
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: reduce-ஐப் பயன்படுத்தும் போது, குறிப்பாக நிதி அல்லது அறிவியல் கணக்கீடுகளுக்கு, வெவ்வேறு தளங்கள் மற்றும் வட்டாரங்களில் துல்லியம் மற்றும் முழுமையாக்கப் பிழைகள் குறித்து கவனமாக இருங்கள். பயனரின் புவியியல் இருப்பிடத்தைப் பொருட்படுத்தாமல் துல்லியமான முடிவுகளை உறுதிப்படுத்த பொருத்தமான லைப்ரரிகள் அல்லது நுட்பங்களைப் பயன்படுத்தவும்.

6. flatMap

flatMap காம்பினேட்டர் உள்ளீட்டு அசிங்க் இட்டரேட்டரால் வெளியிடப்படும் ஒவ்வொரு மதிப்பிற்கும் ஒரு செயல்பாட்டைப் பயன்படுத்துகிறது, இது மற்றொரு அசிங்க் இட்டரேட்டரை வழங்குகிறது. பின்னர் அது விளைந்த அசிங்க் இட்டரேட்டர்களை ஒரே அசிங்க் இட்டரேட்டராக தட்டையாக்குகிறது.

            
async function* flatMap(iterable, fn) {
  for await (const value of iterable) {
    const innerIterable = await fn(value);
    for await (const innerValue of innerIterable) {
      yield innerValue;
    }
  }
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

async function* duplicate(x) {
  await new Promise(resolve => setTimeout(resolve, 50));
  yield x;
  yield x;
}

(async () => {
  const duplicatedNumbers = flatMap(numberGenerator(), duplicate);
  for await (const value of duplicatedNumbers) {
    console.log(value); // Output: 1, 1, 2, 2, 3, 3 (with delays)
  }
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: ஒரு தரவு ஸ்ட்ரீமை தொடர்புடைய தரவுகளின் ஸ்ட்ரீமாக மாற்றுவதற்கு flatMap பயனுள்ளதாக இருக்கும். உதாரணமாக, அசல் ஸ்ட்ரீமின் ஒவ்வொரு கூறும் ஒரு நாட்டைக் குறித்தால், உருமாற்றச் செயல்பாடு அந்த நாட்டிலுள்ள நகரங்களின் பட்டியலைப் பெறலாம். பல்வேறு உலகளாவிய மூலங்களிலிருந்து தரவைப் பெறும்போது API விகித வரம்புகள் மற்றும் தாமதம் குறித்து எச்சரிக்கையாக இருங்கள், மேலும் பொருத்தமான கேச்சிங் அல்லது த்ராட்லிங் வழிமுறைகளைச் செயல்படுத்தவும்.

7. forEach

forEach காம்பினேட்டர் உள்ளீட்டு அசிங்க் இட்டரேட்டரிலிருந்து ஒவ்வொரு மதிப்பிற்கும் ஒரு முறை கொடுக்கப்பட்ட செயல்பாட்டைச் செயல்படுத்துகிறது. மற்ற காம்பினேட்டர்களைப் போலல்லாமல், இது ஒரு புதிய அசிங்க் இட்டரேட்டரைத் தராது; இது பக்க விளைவுகளுக்குப் பயன்படுத்தப்படுகிறது.

            
async function forEach(iterable, fn) {
  for await (const value of iterable) {
    await fn(value);
  }
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

async function logNumber(x) {
  await new Promise(resolve => setTimeout(resolve, 50));
  console.log("Processing:", x);
}

(async () => {
  await forEach(numberGenerator(), logNumber);
  console.log("Done processing.");
  // Output: Processing: 1, Processing: 2, Processing: 3, Done processing. (with delays)
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: forEach-ஐ லாக்கிங், அறிவிப்புகளை அனுப்புதல் அல்லது UI கூறுகளைப் புதுப்பித்தல் போன்ற செயல்களைத் தூண்டுவதற்குப் பயன்படுத்தலாம். உலகளவில் விநியோகிக்கப்பட்ட பயன்பாட்டில் இதைப் பயன்படுத்தும்போது, வெவ்வேறு நேர மண்டலங்களில் அல்லது மாறுபட்ட நெட்வொர்க் நிலைமைகளின் கீழ் செயல்களைச் செய்வதன் தாக்கங்களைக் கருத்தில் கொள்ளுங்கள். நம்பகத்தன்மையை உறுதிப்படுத்த சரியான பிழை கையாளுதல் மற்றும் மீண்டும் முயற்சிக்கும் வழிமுறைகளைச் செயல்படுத்தவும்.

8. toArray

toArray காம்பினேட்டர் உள்ளீட்டு அசிங்க் இட்டரேட்டரிலிருந்து அனைத்து மதிப்புகளையும் ஒரு அரேவில் சேகரிக்கிறது.

            
async function toArray(iterable) {
  const result = [];
  for await (const value of iterable) {
    result.push(value);
  }
  return result;
}

// Example:
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

(async () => {
  const numbersArray = await toArray(numberGenerator());
  console.log(numbersArray); // Output: [1, 2, 3]
})();

            

              
                Copy
              
            
          

உலகளாவிய கருத்தாய்வு: சாத்தியமான எல்லையற்ற அல்லது மிக பெரிய ஸ்ட்ரீம்களுடன் கையாளும் போது toArray-ஐ எச்சரிக்கையுடன் பயன்படுத்தவும், ஏனெனில் இது நினைவகப் பற்றாக்குறைக்கு வழிவகுக்கும். மிக பெரிய தரவுத்தொகுப்புகளுக்கு, தரவை துண்டுகளாகச் செயலாக்குவது அல்லது ஸ்ட்ரீமிங் API-களைப் பயன்படுத்துவது போன்ற மாற்று அணுகுமுறைகளைக் கருத்தில் கொள்ளுங்கள். நீங்கள் உலகம் முழுவதிலுமிருந்து பயனர் உருவாக்கிய உள்ளடக்கத்துடன் பணிபுரிகிறீர்கள் என்றால், தரவை ஒரு அரேவில் சேமிக்கும்போது வெவ்வேறு எழுத்து குறியாக்கங்கள் மற்றும் உரை திசைகளைக் குறித்து எச்சரிக்கையாக இருங்கள்.

காம்பினேட்டர்களை ஒருங்கிணைத்தல்

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களின் உண்மையான சக்தி அவற்றின் ஒருங்கிணைப்புத் திறனில் உள்ளது. சிக்கலான தரவு செயலாக்கப் பைப்லைன்களை உருவாக்க நீங்கள் பல காம்பினேட்டர்களை ஒன்றாக இணைக்கலாம்.

எடுத்துக்காட்டாக, உங்களிடம் எண்களின் ஸ்ட்ரீமை வெளியிடும் ஒரு அசிங்க் இட்டரேட்டர் உள்ளது என்று வைத்துக்கொள்வோம், மேலும் நீங்கள் ஒற்றைப்படை எண்களை வடிகட்டவும், இரட்டைப்படை எண்களை வர்க்கப்படுத்தவும், பின்னர் முதல் மூன்று முடிவுகளை எடுக்கவும் விரும்புகிறீர்கள். filter, map மற்றும் take காம்பினேட்டர்களை ஒருங்கிணைப்பதன் மூலம் இதை அடையலாம்:

            
async function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
  yield 6;
  yield 7;
  yield 8;
  yield 9;
  yield 10;
}

async function isEven(x) {
  return x % 2 === 0;
}

async function square(x) {
  return x * x;
}

async function* filter(iterable, predicate) {
    for await (const value of iterable) {
        if (await predicate(value)) {
            yield value;
        }
    }
}

async function* map(iterable, fn) {
    for await (const value of iterable) {
        yield await fn(value);
    }
}

async function* take(iterable, n) {
    let i = 0;
    for await (const value of iterable) {
        if (i < n) {
            yield value;
            i++;
        } else {
            return;
        }
    }
}

(async () => {
  const pipeline = take(map(filter(numberGenerator(), isEven), square), 3);
  for await (const value of pipeline) {
    console.log(value); // Output: 4, 16, 36
  }
})();

            

              
                Copy
              
            
          

எளிய, மீண்டும் பயன்படுத்தக்கூடிய காம்பினேட்டர்களை இணைப்பதன் மூலம் அதிநவீன தரவு உருமாற்றங்களை எவ்வாறு உருவாக்கலாம் என்பதை இது நிரூபிக்கிறது.

நடைமுறை பயன்பாடுகள்

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் பல்வேறு சூழ்நிலைகளில் மதிப்புமிக்கவை, அவற்றுள்:

• நிகழ்நேர தரவு செயலாக்கம்: சென்சார்கள், சமூக ஊடக ஊட்டங்கள் அல்லது நிதிச் சந்தைகளிலிருந்து வரும் தரவு ஸ்ட்ரீம்களைச் செயலாக்குதல்.
• தரவு பைப்லைன்கள்: தரவுக் கிடங்கு மற்றும் பகுப்பாய்வுகளுக்காக ETL (பிரித்தெடுத்தல், உருமாற்றுதல், ஏற்றுதல்) பைப்லைன்களை உருவாக்குதல்.
• ஒத்திசைவற்ற API-கள்: துண்டுகளாகத் தரவை வழங்கும் API-களிலிருந்து தரவைப் பெறுதல்.
• UI புதுப்பிப்புகள்: ஒத்திசைவற்ற நிகழ்வுகளின் அடிப்படையில் பயனர் இடைமுகங்களைப் புதுப்பித்தல்.
• கோப்பு செயலாக்கம்: பெரிய கோப்புகளைப் படித்து, துண்டுகளாகச் செயலாக்குதல்.

எடுத்துக்காட்டு: நிகழ்நேர பங்குத் தரவு

நீங்கள் உலகம் முழுவதிலுமிருந்து நிகழ்நேரப் பங்குத் தரவைக் காட்டும் ஒரு நிதிப் பயன்பாட்டை உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். வெவ்வேறு பங்குகளுக்கான விலை புதுப்பிப்புகளின் ஸ்ட்ரீமை அவற்றின் டிக்கர் சின்னங்களால் அடையாளம் காணப்பட்டுப் பெறுகிறீர்கள். நியூயார்க் பங்குச் சந்தையில் (NYSE) வர்த்தகம் செய்யப்படும் பங்குகளுக்கான புதுப்பிப்புகளை மட்டும் காட்ட இந்த ஸ்ட்ரீமை வடிகட்டவும், பின்னர் ஒவ்வொரு பங்குக்கும் சமீபத்திய விலையைக் காட்டவும் விரும்புகிறீர்கள்.

            
async function* stockDataStream() {
  // Simulate a stream of stock data from different exchanges
  const exchanges = ['NYSE', 'NASDAQ', 'LSE', 'HKEX'];
  const symbols = ['AAPL', 'MSFT', 'GOOG', 'TSLA', 'AMZN', 'BABA'];

  while (true) {
    await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
    const exchange = exchanges[Math.floor(Math.random() * exchanges.length)];
    const symbol = symbols[Math.floor(Math.random() * symbols.length)];
    const price = Math.random() * 2000;

    yield { exchange, symbol, price };
  }
}

async function isNYSE(stock) {
  return stock.exchange === 'NYSE';
}

async function* filter(iterable, predicate) {
  for await (const value of iterable) {
    if (await predicate(value)) {
      yield value;
    }
  }
}


async function toLatestPrices(iterable) {
    const latestPrices = {};
    for await (const stock of iterable) {
        latestPrices[stock.symbol] = stock.price;
    }
    return latestPrices;
}

async function forEach(iterable, fn) {
  for await (const value of iterable) {
    await fn(value);
  }
}


(async () => {
  const nyseStocks = filter(stockDataStream(), isNYSE);
  const updateUI = async (stock) => {
       //Simulate UI update
       console.log(`UI updated with : ${JSON.stringify(stock)}`)
       await new Promise(resolve => setTimeout(resolve, Math.random() * 100));
  }

  forEach(nyseStocks, updateUI);
})();


            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு, ஒரு நிகழ்நேரத் தரவு ஸ்ட்ரீமை திறமையாகச் செயலாக்கவும், தேவையற்ற தரவை வடிகட்டவும், மற்றும் சமீபத்திய தகவலுடன் UI-ஐப் புதுப்பிக்கவும் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களை எவ்வாறு பயன்படுத்தலாம் என்பதைக் காட்டுகிறது. ஒரு நிஜ உலகச் சூழ்நிலையில், நீங்கள் உருவகப்படுத்தப்பட்ட பங்குத் தரவு ஸ்ட்ரீமை ஒரு நிகழ்நேர நிதித் தரவு ஊடாட்டத்துடன் மாற்றுவீர்கள்.

சரியான லைப்ரரியைத் தேர்ந்தெடுத்தல்

நீங்கள் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களை நீங்களே செயல்படுத்த முடியும் என்றாலும், பல லைப்ரரிகள் முன்-கட்டமைக்கப்பட்ட காம்பினேட்டர்கள் மற்றும் பிற பயனுள்ள பயன்பாடுகளை வழங்குகின்றன. சில பிரபலமான விருப்பங்கள் பின்வருமாறு:

• IxJS (Reactive Extensions for JavaScript): Reactive Programming மாதிரியைப் பயன்படுத்தி ஒத்திசைவற்ற மற்றும் நிகழ்வு அடிப்படையிலான தரவுகளுடன் வேலை செய்வதற்கான ஒரு சக்திவாய்ந்த லைப்ரரி. இது அசிங்க் இட்டரேட்டர்களுடன் பயன்படுத்தக்கூடிய ஒரு செழிப்பான ஆபரேட்டர்களின் தொகுப்பைக் கொண்டுள்ளது.
• zen-observable: அப்சர்வேபிள்களுக்கான ஒரு இலகுரக லைப்ரரி, இது எளிதாக அசிங்க் இட்டரேட்டர்களாக மாற்றப்படலாம்.
• Most.js: மற்றொரு செயல்திறன் மிக்க ரியாக்டிவ் ஸ்ட்ரீம்ஸ் லைப்ரரி.

சரியான லைப்ரரியைத் தேர்ந்தெடுப்பது உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் விருப்பங்களைப் பொறுத்தது. பண்டில் அளவு, செயல்திறன் மற்றும் குறிப்பிட்ட காம்பினேட்டர்களின் கிடைக்கும் தன்மை போன்ற காரணிகளைக் கருத்தில் கொள்ளுங்கள்.

செயல்திறன் கருத்தாய்வுகள்

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் ஒத்திசைவற்ற தரவுகளுடன் வேலை செய்ய ஒரு சுத்தமான மற்றும் ஒருங்கிணைக்கக்கூடிய வழியை வழங்கினாலும், செயல்திறன் தாக்கங்களைக் கருத்தில் கொள்வது அவசியம், குறிப்பாக பெரிய தரவு ஸ்ட்ரீம்களைக் கையாளும்போது.

• தேவையற்ற இடைநிலை இட்டரேட்டர்களைத் தவிர்க்கவும்: ஒவ்வொரு காம்பினேட்டரும் ஒரு புதிய அசிங்க் இட்டரேட்டரை உருவாக்குகிறது, இது மேல்நிலையை அறிமுகப்படுத்தலாம். உங்கள் பைப்லைனில் உள்ள காம்பினேட்டர்களின் எண்ணிக்கையைக் குறைக்க முயற்சிக்கவும்.
• திறமையான அல்காரிதங்களைப் பயன்படுத்தவும்: உங்கள் தரவின் அளவு மற்றும் பண்புகளுக்குப் பொருத்தமான அல்காரிதங்களைத் தேர்ந்தெடுக்கவும்.
• பின் அழுத்தத்தைக் கருத்தில் கொள்ளுங்கள்: உங்கள் தரவு மூலம் உங்கள் நுகர்வோர் செயலாக்கக்கூடியதை விட வேகமாகத் தரவை உருவாக்கினால், நினைவகப் பெருக்கத்தைத் தடுக்க பின் அழுத்த வழிமுறைகளைச் செயல்படுத்தவும்.
• உங்கள் கோடை அளவிடவும்: செயல்திறன் தடைகளைக் கண்டறிந்து அதற்கேற்ப உங்கள் கோடை மேம்படுத்த சுயவிவரக் கருவிகளைப் பயன்படுத்தவும்.

சிறந்த நடைமுறைகள்

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களுடன் வேலை செய்வதற்கான சில சிறந்த நடைமுறைகள் இங்கே:

• காம்பினேட்டர்களை சிறியதாகவும் கவனம் செலுத்தியதாகவும் வைத்திருங்கள்: ஒவ்வொரு காம்பினேட்டருக்கும் ஒரு ஒற்றை, நன்கு வரையறுக்கப்பட்ட நோக்கம் இருக்க வேண்டும்.
• யூனிட் சோதனைகளை எழுதுங்கள்: உங்கள் காம்பினேட்டர்கள் எதிர்பார்த்தபடி செயல்படுகின்றனவா என்பதை உறுதிப்படுத்த அவற்றை முழுமையாகச் சோதிக்கவும்.
• விளக்கமான பெயர்களைப் பயன்படுத்தவும்: உங்கள் காம்பினேட்டர்களுக்கு அவற்றின் செயல்பாட்டைத் தெளிவாகக் குறிக்கும் பெயர்களைத் தேர்வுசெய்யவும்.
• உங்கள் கோடை ஆவணப்படுத்தவும்: உங்கள் காம்பினேட்டர்கள் மற்றும் தரவு பைப்லைன்களுக்குத் தெளிவான ஆவணங்களை வழங்கவும்.
• பிழை கையாளுதலைக் கருத்தில் கொள்ளுங்கள்: உங்கள் தரவு ஸ்ட்ரீம்களில் எதிர்பாராத பிழைகளைச் சீராகக் கையாள வலுவான பிழை கையாளுதலைச் செயல்படுத்தவும்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களை உருமாற்றவும் கையாளவும் ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான வழியை வழங்குகின்றன. அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களின் அடிப்படைகளைப் புரிந்துகொண்டு, காம்பினேட்டர்களின் சக்தியைப் பயன்படுத்துவதன் மூலம், நவீன வலை மற்றும் சர்வர்-பக்க பயன்பாடுகளுக்கு திறமையான மற்றும் அளவிடக்கூடிய தரவு செயலாக்கப் பைப்லைன்களை நீங்கள் உருவாக்கலாம். உங்கள் பயன்பாடுகளை வடிவமைக்கும்போது, தரவு வடிவங்கள், பிழை கையாளுதல் மற்றும் வெவ்வேறு பிராந்தியங்கள் மற்றும் கலாச்சாரங்களில் செயல்திறன் ஆகியவற்றின் உலகளாவிய தாக்கங்களைக் கருத்தில் கொண்டு உண்மையிலேயே உலகத் தயாரான தீர்வுகளை உருவாக்குங்கள்.